home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / video / creation.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  61.5 KB  |  1,883 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  * Generated by the ICS builderXcessory (BX).
  19.  *
  20.  *
  21.  * Builder Xcessory 3.0 FT.
  22.  *
  23.  */
  24. /*
  25.  * MOTIF include files needed for widget creation.
  26.  */
  27. #include <Xm/Xm.h>
  28. #include <Xm/TextF.h>
  29. #include <Xm/CascadeB.h>
  30. #include <Xm/PushB.h>
  31. #include <Xm/ToggleB.h>
  32. #include <Xm/Label.h>
  33. #include <Xm/Scale.h>
  34. #include <Xm/MainW.h>
  35. #include <Xm/BulletinB.h>
  36. #include <Xm/RowColumn.h>
  37. #include <Xm/MenuShell.h>
  38.  
  39. #include <vl/vl.h>   
  40.  
  41. #define DECLARE_BX_GLOBALS
  42.  
  43. /*
  44.  * Global declarations are now stored in the header file 'creation.h'.
  45.  *
  46.  * If DECLARE_BX_GLOBALS is defined then this header file
  47.  * declares the globals, otherwise it just externs them.
  48.  */
  49.  
  50. #include "creation.h"
  51.  
  52. extern float Version_number;
  53. extern VLServer vlSvr;  /* for widgets that GetControl upon creation */
  54. extern VLPath   vlPath;
  55. /*
  56.  * Function: BxRegisterConverters()
  57.  *     Registers all the converters for all widgets.
  58.  */
  59. static void
  60. BxRegisterConverters()
  61. {
  62.     XtInitializeWidgetClass(xmTextFieldWidgetClass);
  63.     XtInitializeWidgetClass(xmCascadeButtonWidgetClass);
  64.     XtInitializeWidgetClass(xmPushButtonWidgetClass);
  65.     XtInitializeWidgetClass(xmToggleButtonWidgetClass);
  66.     XtInitializeWidgetClass(xmLabelWidgetClass);
  67.     XtInitializeWidgetClass(xmScaleWidgetClass);
  68.     XtInitializeWidgetClass(xmMainWindowWidgetClass);
  69.     XtInitializeWidgetClass(xmBulletinBoardWidgetClass);
  70.     XtInitializeWidgetClass(xmRowColumnWidgetClass);
  71.     XtInitializeWidgetClass(topLevelShellWidgetClass);
  72.     XtInitializeWidgetClass(xmMenuShellWidgetClass);
  73. }
  74.  
  75. /*
  76.  * Function prototypes for convenience routines
  77.  * located in utilities file.
  78.  */
  79.  
  80. #ifndef IGNORE_XPM_PIXMAP
  81. extern XPM_PIXMAP();
  82. #endif /* IGNORE_XPM_PIXMAP */
  83.  
  84. #ifndef IGNORE_MENU_POST
  85. extern void MENU_POST();
  86. #endif /* IGNORE_MENU_POST */
  87.  
  88. #ifndef IGNORE_CONVERT
  89. extern XtPointer CONVERT();
  90. #endif /* IGNORE_CONVERT */
  91.  
  92. /*
  93.  * Function: CreatechromaShell()
  94.  */
  95. Widget
  96. CreatechromaShell( parent)
  97. Widget parent;
  98. {
  99.     Arg        args[512];
  100.     Cardinal       argcnt;
  101.     Boolean       argok;
  102.     Widget     retval;
  103.     Widget    chromaShell;
  104.  
  105.     XtInitializeWidgetClass(topLevelShellWidgetClass);
  106.     argcnt = 0;
  107.     XtSetArg(args[argcnt], XmNkeyboardFocusPolicy, XmPOINTER); argcnt++;
  108.     XtSetArg(args[argcnt], XmNx, 747); argcnt++;
  109.     XtSetArg(args[argcnt], XmNy, 703); argcnt++;
  110.     chromaShell =  XtCreatePopupShell( "chromactlShell", 
  111.         topLevelShellWidgetClass, parent, args, argcnt);
  112.     retval = chromaShell;
  113. }
  114.  
  115. /*
  116.  * Function: CreatelumaShell()
  117.  */
  118. Widget
  119. CreatelumaShell( parent)
  120. Widget parent;
  121. {
  122.     Arg        args[512];
  123.     Cardinal       argcnt;
  124.     Boolean       argok;
  125.     Widget     retval;
  126.     Widget    lumaShell;
  127.  
  128.     XtInitializeWidgetClass(topLevelShellWidgetClass);
  129.     argcnt = 0;
  130.     XtSetArg(args[argcnt], XmNkeyboardFocusPolicy, XmPOINTER); argcnt++;
  131.     XtSetArg(args[argcnt], XmNx, 1015); argcnt++;
  132.     XtSetArg(args[argcnt], XmNy, 702); argcnt++;
  133.     lumaShell =  XtCreatePopupShell( "lumactlShell", 
  134.         topLevelShellWidgetClass, parent, args, argcnt);
  135.     retval = lumaShell;
  136. }
  137. /*
  138.  * Function: CreateswitchShell()
  139.  */
  140. Widget
  141. CreateswitchShell( parent)
  142. Widget parent;
  143. {
  144.     Arg        args[512];
  145.     Cardinal       argcnt;
  146.     Boolean       argok;
  147.     Widget     retval;
  148.     Widget    switchShell;
  149.  
  150.     XtInitializeWidgetClass(topLevelShellWidgetClass);
  151.     argcnt = 0;
  152.     XtSetArg(args[argcnt], XmNkeyboardFocusPolicy, XmPOINTER); argcnt++;
  153.     XtSetArg(args[argcnt], XmNx, 993); argcnt++;
  154.     XtSetArg(args[argcnt], XmNy, 447); argcnt++;
  155.     switchShell =  XtCreatePopupShell( "switchShell", 
  156.         topLevelShellWidgetClass, parent, args, argcnt);
  157.     retval = switchShell;
  158. }
  159.  
  160.  
  161. /*
  162.  * Function: CreatemainWindow()
  163.  *        Create mainWindow hierarchy of widgets.
  164.  */
  165. Widget
  166. CreatemainWindow( parent)
  167. Widget parent;
  168. {
  169.     Arg        args[512];
  170.     Cardinal       argcnt;
  171.     Boolean       argok;
  172.     Widget     retval;
  173.     Widget    mainWindow;
  174.     Widget    menuBar;
  175.     Widget    fileCButton;
  176.     Widget    menuShell;
  177.     Widget    pulldownMenu;
  178.     Widget    quitPB;
  179.     Widget    optionsCButton;
  180.     Widget    menuShell1;
  181.     Widget    pulldownMenu2;
  182.     Widget    option1PB;
  183.     Widget    appsCButton;
  184.     Widget    menuShell2;
  185.     Widget    pulldownMenu4;
  186.     Widget    app1PB;
  187.     Widget    app2PB;
  188.     Widget    app3PB;
  189.     Widget    app4PB;
  190.     Widget    app5PB;
  191.     Widget    app6PB;
  192.     Widget    utilitiesCascadeButton;
  193.     Widget    menuShell3;
  194.     Widget    pulldownMenu1;
  195.     Widget    util1PB;
  196.     Widget    util2PB;
  197.     Widget    helpCButton;
  198.     Widget    menuShell4;
  199.     Widget    pulldownMenu3;
  200.     Widget    helpPB;
  201.     Widget    bulletinBoard;
  202.     Widget    grabnsavePB;
  203.     Widget    grabndispPB;
  204.     Widget    vidovergfxPB;
  205.     Widget    gfxovervidPB;
  206.     Widget    fullscreenoutPB;
  207.  
  208.     argok = False;
  209.  
  210.     BxRegisterConverters();
  211.  
  212.     argcnt = 0;
  213.     XtSetArg(args[argcnt], XmNx, 450); argcnt++;
  214.     XtSetArg(args[argcnt], XmNy, 487); argcnt++;
  215.     XtSetArg(args[argcnt], XmNwidth, 360); argcnt++;
  216.     XtSetArg(args[argcnt], XmNheight, 120); argcnt++;
  217.     mainWindow = XtCreateWidget("mainWindow",
  218.         xmMainWindowWidgetClass,
  219.         parent,
  220.         args,
  221.         argcnt);
  222.     retval = mainWindow;
  223.  
  224.     argcnt = 0;
  225.     XtSetArg(args[argcnt], XmNrowColumnType, XmMENU_BAR); argcnt++;
  226.     XtSetArg(args[argcnt], XmNwidth, 415); argcnt++;
  227.     XtSetArg(args[argcnt], XmNheight, 24); argcnt++;
  228.     menuBar = XtCreateWidget("menuBar",
  229.         xmRowColumnWidgetClass,
  230.         mainWindow,
  231.         args,
  232.         argcnt);
  233.     XtManageChild(menuBar);
  234.  
  235.     argcnt = 0;
  236.     XtSetArg(args[argcnt], XmNx, 5); argcnt++;
  237.     XtSetArg(args[argcnt], XmNy, 2); argcnt++;
  238.     XtSetArg(args[argcnt], XmNwidth, 37); argcnt++;
  239.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  240.     fileCButton = XtCreateWidget("fileCButton",
  241.         xmCascadeButtonWidgetClass,
  242.         menuBar,
  243.         args,
  244.         argcnt);
  245.  
  246.     XtManageChild(fileCButton);
  247.  
  248.     argcnt = 0;
  249.     XtSetArg(args[argcnt], XmNwidth, 1); argcnt++;
  250.     XtSetArg(args[argcnt], XmNheight, 1); argcnt++;
  251.     menuShell = XtCreatePopupShell("menuShell",
  252.         xmMenuShellWidgetClass,
  253.         XtParent(fileCButton),
  254.         args,
  255.         argcnt);
  256.  
  257.     argcnt = 0;
  258.     XtSetArg(args[argcnt], XmNrowColumnType, XmMENU_PULLDOWN); argcnt++;
  259.     XtSetArg(args[argcnt], XmNx, 456); argcnt++;
  260.     XtSetArg(args[argcnt], XmNy, 511); argcnt++;
  261.     XtSetArg(args[argcnt], XmNwidth, 54); argcnt++;
  262.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  263.     pulldownMenu = XtCreateWidget("pulldownMenu",
  264.         xmRowColumnWidgetClass,
  265.         menuShell,
  266.         args,
  267.         argcnt);
  268.  
  269.     argcnt = 0;
  270.     quitPB = XtCreateWidget("quitPB",
  271.         xmPushButtonWidgetClass,
  272.         pulldownMenu,
  273.         args,
  274.         argcnt);
  275.  
  276.     XtAddCallback(quitPB, XmNactivateCallback, quitPBHandler, (XtPointer)0);
  277.     XtManageChild(quitPB);
  278.  
  279.     argcnt = 0;
  280.     XtSetArg(args[argcnt], XmNsubMenuId, pulldownMenu); argcnt++;
  281.     XtSetValues(fileCButton, args, argcnt);
  282.  
  283.     argcnt = 0;
  284.     XtSetArg(args[argcnt], XmNx, 49); argcnt++;
  285.     XtSetArg(args[argcnt], XmNy, 2); argcnt++;
  286.     XtSetArg(args[argcnt], XmNwidth, 62); argcnt++;
  287.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  288.     optionsCButton = XtCreateWidget("optionsCButton",
  289.         xmCascadeButtonWidgetClass,
  290.         menuBar,
  291.         args,
  292.         argcnt);
  293.  
  294.     XtManageChild(optionsCButton);
  295.  
  296.     argcnt = 0;
  297.     XtSetArg(args[argcnt], XmNwidth, 1); argcnt++;
  298.     XtSetArg(args[argcnt], XmNheight, 1); argcnt++;
  299.     menuShell1 = XtCreatePopupShell("menuShell1",
  300.         xmMenuShellWidgetClass,
  301.         XtParent(optionsCButton),
  302.         args,
  303.         argcnt);
  304.  
  305.     argcnt = 0;
  306.     XtSetArg(args[argcnt], XmNrowColumnType, XmMENU_PULLDOWN); argcnt++;
  307.     XtSetArg(args[argcnt], XmNx, 500); argcnt++;
  308.     XtSetArg(args[argcnt], XmNy, 511); argcnt++;
  309.     XtSetArg(args[argcnt], XmNwidth, 149); argcnt++;
  310.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  311.     pulldownMenu2 = XtCreateWidget("pulldownMenu2",
  312.         xmRowColumnWidgetClass,
  313.         menuShell1,
  314.         args,
  315.         argcnt);
  316.  
  317.     argcnt = 0;
  318.     option1PB = XtCreateWidget("option1PB",
  319.         xmPushButtonWidgetClass,
  320.         pulldownMenu2,
  321.         args,
  322.         argcnt);
  323.  
  324.     XtAddCallback(option1PB, XmNactivateCallback, option1PBHandler, (XtPointer)0);
  325.     XtManageChild(option1PB);
  326.  
  327.     argcnt = 0;
  328.     XtSetArg(args[argcnt], XmNsubMenuId, pulldownMenu2); argcnt++;
  329.     XtSetValues(optionsCButton, args, argcnt);
  330.  
  331.     argcnt = 0;
  332.     XtSetArg(args[argcnt], XmNlabelString, 
  333.              CONVERT(parent,"Apps", "XmString", 0, &argok)); if (argok) argcnt++;
  334.     XtSetArg(args[argcnt], XmNx, 118); argcnt++;
  335.     XtSetArg(args[argcnt], XmNy, 2); argcnt++;
  336.     XtSetArg(args[argcnt], XmNwidth, 47); argcnt++;
  337.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  338.     appsCButton = XtCreateWidget("appsCButton",
  339.         xmCascadeButtonWidgetClass,
  340.         menuBar,
  341.         args,
  342.         argcnt);
  343.  
  344.     XtManageChild(appsCButton);
  345.  
  346.     argcnt = 0;
  347.     XtSetArg(args[argcnt], XmNwidth, 1); argcnt++;
  348.     XtSetArg(args[argcnt], XmNheight, 1); argcnt++;
  349.     menuShell2 = XtCreatePopupShell("menuShell2",
  350.         xmMenuShellWidgetClass,
  351.         XtParent(appsCButton),
  352.         args,
  353.         argcnt);
  354.  
  355.     argcnt = 0;
  356.     XtSetArg(args[argcnt], XmNrowColumnType, XmMENU_PULLDOWN); argcnt++;
  357.     XtSetArg(args[argcnt], XmNx, 569); argcnt++;
  358.     XtSetArg(args[argcnt], XmNy, 511); argcnt++;
  359.     XtSetArg(args[argcnt], XmNwidth, 119); argcnt++;
  360.     XtSetArg(args[argcnt], XmNheight, 148); argcnt++;
  361.     pulldownMenu4 = XtCreateWidget("pulldownMenu4",
  362.         xmRowColumnWidgetClass,
  363.         menuShell2,
  364.         args,
  365.         argcnt);
  366.  
  367.     argcnt = 0;
  368.     app1PB = XtCreateWidget("app1PB",
  369.         xmPushButtonWidgetClass,
  370.         pulldownMenu4,
  371.         args,
  372.         argcnt);
  373.  
  374.     XtAddCallback(app1PB, XmNactivateCallback, app1PBHandler, (XtPointer)0);
  375.     XtManageChild(app1PB);
  376.  
  377.     argcnt = 0;
  378.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  379.     app2PB = XtCreateWidget("app2PB",
  380.         xmPushButtonWidgetClass,
  381.         pulldownMenu4,
  382.         args,
  383.         argcnt);
  384.  
  385.     XtAddCallback(app2PB, XmNactivateCallback, app2PBHandler, (XtPointer)0);
  386.     XtManageChild(app2PB);
  387.  
  388.     argcnt = 0;
  389.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  390.     app3PB = XtCreateWidget("app3PB",
  391.         xmPushButtonWidgetClass,
  392.         pulldownMenu4,
  393.         args,
  394.         argcnt);
  395.  
  396.     XtAddCallback(app3PB, XmNactivateCallback, app3PBHandler, (XtPointer)0);
  397.     XtManageChild(app3PB);
  398.  
  399.     argcnt = 0;
  400.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  401.     app4PB = XtCreateWidget("app4PB",
  402.         xmPushButtonWidgetClass,
  403.         pulldownMenu4,
  404.         args,
  405.         argcnt);
  406.  
  407.     XtAddCallback(app4PB, XmNactivateCallback, app4PBHandler, (XtPointer)0);
  408.     XtManageChild(app4PB);
  409.  
  410.     argcnt = 0;
  411.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  412.     app5PB = XtCreateWidget("app5PB",
  413.         xmPushButtonWidgetClass,
  414.         pulldownMenu4,
  415.         args,
  416.         argcnt);
  417.  
  418.     XtAddCallback(app5PB, XmNactivateCallback, app5PBHandler, (XtPointer)0);
  419.     XtManageChild(app5PB);
  420.  
  421.     argcnt = 0;
  422.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  423.     app6PB = XtCreateWidget("app6PB",
  424.         xmPushButtonWidgetClass,
  425.         pulldownMenu4,
  426.         args,
  427.         argcnt);
  428.  
  429.     XtAddCallback(app6PB, XmNactivateCallback, app6PBHandler, (XtPointer)0);
  430.     XtManageChild(app6PB);
  431.  
  432.     argcnt = 0;
  433.     XtSetArg(args[argcnt], XmNsubMenuId, pulldownMenu4); argcnt++;
  434.     XtSetValues(appsCButton, args, argcnt);
  435.  
  436.     argcnt = 0;
  437.     XtSetArg(args[argcnt], XmNx, 172); argcnt++;
  438.     XtSetArg(args[argcnt], XmNy, 2); argcnt++;
  439.     XtSetArg(args[argcnt], XmNwidth, 61); argcnt++;
  440.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  441.     utilitiesCascadeButton = XtCreateWidget("utilitiesCascadeButton",
  442.         xmCascadeButtonWidgetClass,
  443.         menuBar,
  444.         args,
  445.         argcnt);
  446.  
  447.     XtManageChild(utilitiesCascadeButton);
  448.  
  449.     argcnt = 0;
  450.     XtSetArg(args[argcnt], XmNwidth, 1); argcnt++;
  451.     XtSetArg(args[argcnt], XmNheight, 1); argcnt++;
  452.     menuShell3 = XtCreatePopupShell("menuShell3",
  453.         xmMenuShellWidgetClass,
  454.         XtParent(utilitiesCascadeButton),
  455.         args,
  456.         argcnt);
  457.  
  458.     argcnt = 0;
  459.     XtSetArg(args[argcnt], XmNrowColumnType, XmMENU_PULLDOWN); argcnt++;
  460.     XtSetArg(args[argcnt], XmNx, 623); argcnt++;
  461.     XtSetArg(args[argcnt], XmNy, 511); argcnt++;
  462.     XtSetArg(args[argcnt], XmNwidth, 143); argcnt++;
  463.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  464.     pulldownMenu1 = XtCreateWidget("pulldownMenu1",
  465.         xmRowColumnWidgetClass,
  466.         menuShell3,
  467.         args,
  468.         argcnt);
  469.  
  470.     argcnt = 0;
  471.     util1PB = XtCreateWidget("util1PB",
  472.         xmPushButtonWidgetClass,
  473.         pulldownMenu1,
  474.         args,
  475.         argcnt);
  476.  
  477.     XtAddCallback(util1PB, XmNactivateCallback, util1PBHandler, (XtPointer)0);
  478.     XtManageChild(util1PB);
  479.  
  480.     argcnt = 0;
  481.     util2PB = XtCreateWidget("util2PB",
  482.         xmPushButtonWidgetClass,
  483.         pulldownMenu1,
  484.         args,
  485.         argcnt);
  486.  
  487.     XtAddCallback(util2PB, XmNactivateCallback, util2PBHandler, (XtPointer)0);
  488.     XtManageChild(util2PB);
  489.  
  490.     argcnt = 0;
  491.     XtSetArg(args[argcnt], XmNsubMenuId, pulldownMenu1); argcnt++;
  492.     XtSetValues(utilitiesCascadeButton, args, argcnt);
  493.  
  494.     argcnt = 0;
  495.     XtSetArg(args[argcnt], XmNx, 240); argcnt++;
  496.     XtSetArg(args[argcnt], XmNy, 2); argcnt++;
  497.     XtSetArg(args[argcnt], XmNwidth, 44); argcnt++;
  498.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  499.     helpCButton = XtCreateWidget("helpCButton",
  500.         xmCascadeButtonWidgetClass,
  501.         menuBar,
  502.         args,
  503.         argcnt);
  504.  
  505.     XtManageChild(helpCButton);
  506.  
  507.     argcnt = 0;
  508.     XtSetArg(args[argcnt], XmNwidth, 1); argcnt++;
  509.     XtSetArg(args[argcnt], XmNheight, 1); argcnt++;
  510.     menuShell4 = XtCreatePopupShell("menuShell4",
  511.         xmMenuShellWidgetClass,
  512.         XtParent(helpCButton),
  513.         args,
  514.         argcnt);
  515.  
  516.     argcnt = 0;
  517.     XtSetArg(args[argcnt], XmNrowColumnType, XmMENU_PULLDOWN); argcnt++;
  518.     XtSetArg(args[argcnt], XmNx, 691); argcnt++;
  519.     XtSetArg(args[argcnt], XmNy, 511); argcnt++;
  520.     XtSetArg(args[argcnt], XmNwidth, 180); argcnt++;
  521.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  522.     pulldownMenu3 = XtCreateWidget("pulldownMenu3",
  523.         xmRowColumnWidgetClass,
  524.         menuShell4,
  525.         args,
  526.         argcnt);
  527.  
  528.     argcnt = 0;
  529.     helpPB = XtCreateWidget("helpPB",
  530.         xmPushButtonWidgetClass,
  531.         pulldownMenu3,
  532.         args,
  533.         argcnt);
  534.  
  535.     XtAddCallback(helpPB, XmNactivateCallback, helpPBHandler, (XtPointer)0);
  536.     XtManageChild(helpPB);
  537.  
  538.     argcnt = 0;
  539.     XtSetArg(args[argcnt], XmNsubMenuId, pulldownMenu3); argcnt++;
  540.     XtSetValues(helpCButton, args, argcnt);
  541.  
  542.     argcnt = 0;
  543.     XtSetArg(args[argcnt], XmNresizePolicy, XmRESIZE_GROW); argcnt++;
  544.     XtSetArg(args[argcnt], XmNwidth, 360); argcnt++;
  545.     XtSetArg(args[argcnt], XmNheight, 120); argcnt++;
  546.     bulletinBoard = XtCreateWidget("bulletinBoard",
  547.         xmBulletinBoardWidgetClass,
  548.         mainWindow,
  549.         args,
  550.         argcnt);
  551.     XtManageChild(bulletinBoard);
  552.  
  553. /* we're not going to use this fullscreen out button for now
  554.  *    argcnt = 0;
  555.  *    XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  556.  *    XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  557.  *    XtSetArg(args[argcnt], XmNx, 10); argcnt++;
  558.  *    XtSetArg(args[argcnt], XmNy, 80); argcnt++;
  559.  *    XtSetArg(args[argcnt], XmNwidth, 110); argcnt++;
  560.  *    XtSetArg(args[argcnt], XmNheight, 25); argcnt++;
  561.  *    fullscreenoutPB = XtCreateWidget("fullscreenoutPB",
  562.  *        xmPushButtonWidgetClass,
  563.  *        bulletinBoard,
  564.  *        args,
  565.  *        argcnt);
  566.  *    XtAddCallback(fullscreenoutPB, XmNactivateCallback, fullscreenoutPBHandler, (XtPointer)0);
  567.  *    XtManageChild(fullscreenoutPB);
  568.  */
  569.  
  570. /* the following two buttons only for all-VL version */
  571. if (Version_number != 1){
  572.     argcnt = 0;
  573.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  574.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  575.     XtSetArg(args[argcnt], XmNx, 130); argcnt++;
  576.     XtSetArg(args[argcnt], XmNy, 50); argcnt++;
  577.     XtSetArg(args[argcnt], XmNwidth, 110); argcnt++;
  578.     XtSetArg(args[argcnt], XmNheight, 25); argcnt++;
  579.     gfxovervidPB = XtCreateWidget("gfxovervidPB",
  580.         xmPushButtonWidgetClass,
  581.         bulletinBoard,
  582.         args,
  583.         argcnt);
  584.  
  585.     XtAddCallback(gfxovervidPB, XmNactivateCallback, gfxovervidPBHandler, (XtPointer)0);
  586.     XtManageChild(gfxovervidPB);
  587.  
  588.     argcnt = 0;
  589.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  590.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  591.     XtSetArg(args[argcnt], XmNx, 10); argcnt++;
  592.     XtSetArg(args[argcnt], XmNy, 50); argcnt++;
  593.     XtSetArg(args[argcnt], XmNwidth, 110); argcnt++;
  594.     XtSetArg(args[argcnt], XmNheight, 25); argcnt++;
  595.     vidovergfxPB = XtCreateWidget("vidovergfxPB",
  596.         xmPushButtonWidgetClass,
  597.         bulletinBoard,
  598.         args,
  599.         argcnt);
  600.  
  601.     XtAddCallback(vidovergfxPB, XmNactivateCallback, vidovergfxPBHandler, (XtPointer)0);
  602.     XtManageChild(vidovergfxPB);
  603.  
  604. } /* end if Version_number not equal to 1 */
  605.  
  606.     argcnt = 0;
  607.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  608.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  609.     XtSetArg(args[argcnt], XmNx, 130); argcnt++;
  610.     XtSetArg(args[argcnt], XmNy, 20); argcnt++;
  611.     XtSetArg(args[argcnt], XmNwidth, 110); argcnt++;
  612.     XtSetArg(args[argcnt], XmNheight, 25); argcnt++;
  613.     grabndispPB = XtCreateWidget("grabndispPB",
  614.         xmPushButtonWidgetClass,
  615.         bulletinBoard,
  616.         args,
  617.         argcnt);
  618.  
  619.     XtAddCallback(grabndispPB, XmNactivateCallback, grabndispPBHandler, (XtPointer)0);
  620.     XtManageChild(grabndispPB);
  621.  
  622.     argcnt = 0;
  623.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  624.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  625.     XtSetArg(args[argcnt], XmNx, 10); argcnt++;
  626.     XtSetArg(args[argcnt], XmNy, 20); argcnt++;
  627.     XtSetArg(args[argcnt], XmNwidth, 110); argcnt++;
  628.     XtSetArg(args[argcnt], XmNheight, 25); argcnt++;
  629.     grabnsavePB = XtCreateWidget("grabnsavePB",
  630.         xmPushButtonWidgetClass,
  631.         bulletinBoard,
  632.         args,
  633.         argcnt);
  634.  
  635.     XtAddCallback(grabnsavePB, XmNactivateCallback, grabnsavePBHandler, (XtPointer)0);
  636.     XtManageChild(grabnsavePB);
  637.  
  638.     return( retval );
  639. }
  640.  
  641. /*
  642.  * Function: CreatechromaBBoard()
  643.  *        Create chromaBBoard hierarchy of widgets.
  644.  */
  645. Widget
  646. CreatechromaBBoard( parent)
  647. Widget parent;
  648. {
  649.     Arg        args[512];
  650.     Cardinal       argcnt;
  651.     Boolean       argok;
  652.     char    text[50];
  653.     VLControlValue vlgotval;
  654.     int        scalevals[5];
  655.     int        umin,umax,vmin,vmax;
  656.     Widget     retval;
  657.     Widget    chromaBBoard;
  658.     Widget    uminTF; 
  659.     Widget    umaxTF; 
  660.     Widget    vminTF;
  661.     Widget    vmaxTF;
  662.     Widget    chromasharpTF;
  663.     Widget    uminScale;
  664.     Widget    umaxScale;
  665.     Widget    urangelockTB;
  666.     Widget    vminScale;
  667.     Widget    vmaxScale;
  668.     Widget    vrangelockTB;
  669.     Widget    chromasharpScale;
  670.     Widget    uminLabel;
  671.     Widget    umaxLabel;
  672.     Widget    vminLabel;
  673.     Widget    vmaxLabel;
  674.     Widget    chromasharpLabel;
  675.     Widget    chromasetTB;
  676.     Widget    chromaDoPB;
  677.     Widget    chromaAPB;
  678.     Widget    chromaBPB;
  679.     Widget    chroma1PB;
  680.     Widget    chroma2PB;
  681.     Widget    chroma3PB;
  682.     Widget    chroma4PB;
  683.  
  684.     argok = False;
  685.  
  686.     BxRegisterConverters();
  687.  
  688.     /* get values for the sliders from current VL state */
  689.     getAllChromaVLValues(&scalevals);
  690.     rangevaltominmax(scalevals[0],scalevals[1],&umin,&umax);
  691.     rangevaltominmax(scalevals[2],scalevals[3],&vmin,&vmax);
  692.  
  693.     argcnt = 0;
  694.     XtSetArg(args[argcnt], XmNresizePolicy, XmRESIZE_GROW); argcnt++;
  695.     XtSetArg(args[argcnt], XmNx, 747); argcnt++;
  696.     XtSetArg(args[argcnt], XmNy, 703); argcnt++;
  697.     XtSetArg(args[argcnt], XmNwidth, 249); argcnt++;
  698.     XtSetArg(args[argcnt], XmNheight, 310); argcnt++;
  699.     chromaBBoard = XtCreateWidget("chromaBBoard",
  700.         xmBulletinBoardWidgetClass,
  701.         parent,
  702.         args,
  703.         argcnt);
  704.     XtAddCallback(chromaBBoard, XmNdestroyCallback, chromaBBdestroyHandler,
  705.           (XtPointer)0);
  706.     retval = chromaBBoard;
  707.  
  708.     argcnt = 0;
  709.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  710.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  711.     XtSetArg(args[argcnt], XmNx, 170); argcnt++;
  712.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  713.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  714.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  715.     chroma4PB = XtCreateWidget("chroma4PB",
  716.         xmPushButtonWidgetClass,
  717.         chromaBBoard,
  718.         args,
  719.         argcnt);
  720.  
  721.     XtAddCallback(chroma4PB, XmNactivateCallback, chroma4PBHandler, (XtPointer)0);
  722.     XtManageChild(chroma4PB);
  723.  
  724.     argcnt = 0;
  725.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  726.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  727.     XtSetArg(args[argcnt], XmNx, 150); argcnt++;
  728.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  729.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  730.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  731.     chroma3PB = XtCreateWidget("chroma3PB",
  732.         xmPushButtonWidgetClass,
  733.         chromaBBoard,
  734.         args,
  735.         argcnt);
  736.  
  737.     XtAddCallback(chroma3PB, XmNactivateCallback, chroma3PBHandler, (XtPointer)0);
  738.     XtManageChild(chroma3PB);
  739.  
  740.     argcnt = 0;
  741.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  742.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  743.     XtSetArg(args[argcnt], XmNx, 130); argcnt++;
  744.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  745.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  746.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  747.     chroma2PB = XtCreateWidget("chroma2PB",
  748.         xmPushButtonWidgetClass,
  749.         chromaBBoard,
  750.         args,
  751.         argcnt);
  752.  
  753.     XtAddCallback(chroma2PB, XmNactivateCallback, chroma2PBHandler, (XtPointer)0);
  754.     XtManageChild(chroma2PB);
  755.  
  756.     argcnt = 0;
  757.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  758.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  759.     XtSetArg(args[argcnt], XmNx, 110); argcnt++;
  760.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  761.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  762.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  763.     chroma1PB = XtCreateWidget("chroma1PB",
  764.         xmPushButtonWidgetClass,
  765.         chromaBBoard,
  766.         args,
  767.         argcnt);
  768.  
  769.     XtAddCallback(chroma1PB, XmNactivateCallback, chroma1PBHandler, (XtPointer)0);
  770.     XtManageChild(chroma1PB);
  771.  
  772.     argcnt = 0;
  773.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  774.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  775.     XtSetArg(args[argcnt], XmNx, 90); argcnt++;
  776.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  777.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  778.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  779.     chromaBPB = XtCreateWidget("chromaBPB",
  780.         xmPushButtonWidgetClass,
  781.         chromaBBoard,
  782.         args,
  783.         argcnt);
  784.  
  785.     XtAddCallback(chromaBPB, XmNactivateCallback, chromaBPBHandler, (XtPointer)0);
  786.     XtManageChild(chromaBPB);
  787.  
  788.     argcnt = 0;
  789.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  790.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  791.     XtSetArg(args[argcnt], XmNx, 70); argcnt++;
  792.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  793.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  794.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  795.     chromaAPB = XtCreateWidget("chromaAPB",
  796.         xmPushButtonWidgetClass,
  797.         chromaBBoard,
  798.         args,
  799.         argcnt);
  800.  
  801.     XtAddCallback(chromaAPB, XmNactivateCallback, chromaAPBHandler, (XtPointer)0);
  802.     XtManageChild(chromaAPB);
  803.  
  804.     argcnt = 0;
  805.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  806.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  807.     XtSetArg(args[argcnt], XmNx, 20); argcnt++;
  808.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  809.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  810.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  811.     chromaDoPB = XtCreateWidget("chromaDoPB",
  812.         xmPushButtonWidgetClass,
  813.         chromaBBoard,
  814.         args,
  815.         argcnt);
  816.  
  817.     XtAddCallback(chromaDoPB, XmNactivateCallback, chromaDoPBHandler, (XtPointer)0);
  818.     XtManageChild(chromaDoPB);
  819.  
  820.     argcnt = 0;
  821.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  822.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  823.     XtSetArg(args[argcnt], XmNx, 190); argcnt++;
  824.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  825.     XtSetArg(args[argcnt], XmNwidth, 50); argcnt++;
  826.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  827.     chromasetTB = XtCreateWidget("chromasetTB",
  828.         xmToggleButtonWidgetClass,
  829.         chromaBBoard,
  830.         args,
  831.         argcnt);
  832.  
  833.     XtAddCallback(chromasetTB, XmNvalueChangedCallback, chromasetTBHandler, (XtPointer)0);
  834.     XtManageChild(chromasetTB);
  835.     ChromasetTB = chromasetTB; /* set global */
  836.  
  837.     argcnt = 0;
  838.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  839.     XtSetArg(args[argcnt], XmNx, 180); argcnt++;
  840.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  841.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  842.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  843.     chromasharpLabel = XtCreateWidget("chromasharpLabel",
  844.         xmLabelWidgetClass,
  845.         chromaBBoard,
  846.         args,
  847.         argcnt);
  848.     XtManageChild(chromasharpLabel);
  849.  
  850.     argcnt = 0;
  851.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  852.     XtSetArg(args[argcnt], XmNx, 140); argcnt++;
  853.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  854.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  855.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  856.     vmaxLabel = XtCreateWidget("vmaxLabel",
  857.         xmLabelWidgetClass,
  858.         chromaBBoard,
  859.         args,
  860.         argcnt);
  861.     XtManageChild(vmaxLabel);
  862.  
  863.     argcnt = 0;
  864.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  865.     XtSetArg(args[argcnt], XmNx, 100); argcnt++;
  866.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  867.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  868.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  869.     vminLabel = XtCreateWidget("vminLabel",
  870.         xmLabelWidgetClass,
  871.         chromaBBoard,
  872.         args,
  873.         argcnt);
  874.     XtManageChild(vminLabel);
  875.  
  876.     argcnt = 0;
  877.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  878.     XtSetArg(args[argcnt], XmNx, 60); argcnt++;
  879.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  880.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  881.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  882.     umaxLabel = XtCreateWidget("umaxLabel",
  883.         xmLabelWidgetClass,
  884.         chromaBBoard,
  885.         args,
  886.         argcnt);
  887.     XtManageChild(umaxLabel);
  888.  
  889.     argcnt = 0;
  890.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  891.     XtSetArg(args[argcnt], XmNx, 20); argcnt++;
  892.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  893.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  894.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  895.     uminLabel = XtCreateWidget("uminLabel",
  896.         xmLabelWidgetClass,
  897.         chromaBBoard,
  898.         args,
  899.         argcnt);
  900.     XtManageChild(uminLabel);
  901.  
  902.  
  903.     argcnt = 0;
  904.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  905.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  906.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  907.     XtSetArg(args[argcnt], XmNx, 192); argcnt++;
  908.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  909.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  910.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  911.     XtSetArg(args[argcnt], XmNminimum, -8); argcnt++;
  912.     XtSetArg(args[argcnt], XmNmaximum, 7); argcnt++;
  913.     XtSetArg(args[argcnt], XmNvalue, scalevals[4]); argcnt++;
  914.     chromasharpScale = XtCreateWidget("chromasharpScale",
  915.         xmScaleWidgetClass,
  916.         chromaBBoard,
  917.         args,
  918.         argcnt);
  919.     XtAddCallback(chromasharpScale, XmNdragCallback, chromasharpScaleHandler, (XtPointer)0);
  920.     XtAddCallback(chromasharpScale, XmNvalueChangedCallback, chromasharpScaleHandler, (XtPointer)0);
  921.     XtManageChild(chromasharpScale);
  922.     ChromasharpScale = chromasharpScale; /* set global */
  923.  
  924.     argcnt = 0;
  925.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  926.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  927.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  928.     XtSetArg(args[argcnt], XmNx, 152); argcnt++;
  929.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  930.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  931.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  932.     XtSetArg(args[argcnt], XmNminimum, -179); argcnt++;
  933.     XtSetArg(args[argcnt], XmNmaximum, 179); argcnt++;
  934.     XtSetArg(args[argcnt], XmNvalue, vmax); argcnt++;
  935.     vmaxScale = XtCreateWidget("vmaxScale",
  936.         xmScaleWidgetClass,
  937.         chromaBBoard,
  938.         args,
  939.         argcnt);
  940.  
  941.     XtAddCallback(vmaxScale, XmNdragCallback, vmaxScaleHandler, (XtPointer)0);
  942.     XtAddCallback(vmaxScale, XmNvalueChangedCallback, vmaxScaleHandler, (XtPointer)0);
  943.     XtManageChild(vmaxScale);
  944.     VmaxScale = vmaxScale; /* set global */
  945.  
  946.  
  947.     argcnt = 0;
  948.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  949.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  950.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  951.     XtSetArg(args[argcnt], XmNx, 112); argcnt++;
  952.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  953.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  954.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  955.     XtSetArg(args[argcnt], XmNminimum, -179); argcnt++;
  956.     XtSetArg(args[argcnt], XmNmaximum, 179); argcnt++;
  957.     XtSetArg(args[argcnt], XmNvalue, vmin); argcnt++;
  958.     vminScale = XtCreateWidget("vminScale",
  959.         xmScaleWidgetClass,
  960.         chromaBBoard,
  961.         args,
  962.         argcnt);
  963.  
  964.     XtAddCallback(vminScale, XmNdragCallback, vminScaleHandler, (XtPointer)0);
  965.     XtAddCallback(vminScale, XmNvalueChangedCallback, vminScaleHandler, (XtPointer)0);
  966.     XtManageChild(vminScale);
  967.     VminScale = vminScale;
  968.  
  969.     argcnt = 0;
  970.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  971.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  972.     XtSetArg(args[argcnt], XmNx, 115); argcnt++;
  973.     XtSetArg(args[argcnt], XmNy, 250); argcnt++;
  974.     XtSetArg(args[argcnt], XmNwidth, 50); argcnt++;
  975.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  976.     vrangelockTB = XtCreateWidget("vrangelockTB",
  977.         xmToggleButtonWidgetClass,
  978.         chromaBBoard,
  979.         args,
  980.         argcnt);
  981.  
  982.     XtAddCallback(vrangelockTB, XmNvalueChangedCallback, vrangelockTBHandler, (XtPointer)0);
  983.     XtManageChild(vrangelockTB);
  984.     VrangelockTB = vrangelockTB; /* set global */
  985.  
  986.     argcnt = 0;
  987.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  988.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  989.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  990.     XtSetArg(args[argcnt], XmNx, 72); argcnt++;
  991.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  992.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  993.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  994.     XtSetArg(args[argcnt], XmNminimum, -226); argcnt++;
  995.     XtSetArg(args[argcnt], XmNmaximum, 226); argcnt++;
  996.     XtSetArg(args[argcnt], XmNvalue, umax); argcnt++;
  997.     umaxScale = XtCreateWidget("umaxScale",
  998.         xmScaleWidgetClass,
  999.         chromaBBoard,
  1000.         args,
  1001.         argcnt);
  1002.  
  1003.     XtAddCallback(umaxScale, XmNdragCallback, umaxScaleHandler, (XtPointer)0);
  1004.     XtAddCallback(umaxScale, XmNvalueChangedCallback, umaxScaleHandler, (XtPointer)0);
  1005.     XtManageChild(umaxScale);
  1006.     UmaxScale = umaxScale; /* set global */
  1007.  
  1008.     argcnt = 0;
  1009.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  1010.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  1011.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1012.     XtSetArg(args[argcnt], XmNx, 32); argcnt++;
  1013.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  1014.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  1015.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  1016.     XtSetArg(args[argcnt], XmNminimum, -226); argcnt++;
  1017.     XtSetArg(args[argcnt], XmNmaximum, 226); argcnt++;
  1018.     XtSetArg(args[argcnt], XmNvalue, umin); argcnt++;
  1019.     uminScale = XtCreateWidget("uminScale",
  1020.         xmScaleWidgetClass,
  1021.         chromaBBoard,
  1022.         args,
  1023.         argcnt);
  1024.  
  1025.     XtAddCallback(uminScale, XmNdragCallback, uminScaleHandler, (XtPointer)0);
  1026.     XtAddCallback(uminScale, XmNvalueChangedCallback, uminScaleHandler, (XtPointer)0);
  1027.     XtManageChild(uminScale);
  1028.     UminScale = uminScale; /* set global */
  1029.  
  1030.     argcnt = 0;
  1031.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1032.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1033.     XtSetArg(args[argcnt], XmNx, 35); argcnt++;
  1034.     XtSetArg(args[argcnt], XmNy, 250); argcnt++;
  1035.     XtSetArg(args[argcnt], XmNwidth, 50); argcnt++;
  1036.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1037.     urangelockTB = XtCreateWidget("urangelockTB",
  1038.         xmToggleButtonWidgetClass,
  1039.         chromaBBoard,
  1040.         args,
  1041.         argcnt);
  1042.  
  1043.     XtAddCallback(urangelockTB, XmNvalueChangedCallback, urangelockTBHandler, (XtPointer)0);
  1044.     XtManageChild(urangelockTB);
  1045.     UrangelockTB = urangelockTB; /* set global */
  1046.  
  1047.  
  1048.     argcnt = 0;
  1049.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1050.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1051.     XtSetArg(args[argcnt], XmNx, 180); argcnt++;
  1052.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1053.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1054.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1055.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1056.     sprintf(text, "%d", scalevals[4]); 
  1057.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1058. /*    XtSetArg(args[argcnt], XmNvalue, "0"); argcnt++;  */
  1059.     chromasharpTF = XtCreateWidget("chromasharpTF",
  1060.         xmTextFieldWidgetClass,
  1061.         chromaBBoard,
  1062.         args,
  1063.         argcnt);
  1064.     XtManageChild(chromasharpTF);
  1065.     ChromasharpTF = chromasharpTF; /* set global */
  1066.  
  1067.     argcnt = 0;
  1068.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1069.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1070.     XtSetArg(args[argcnt], XmNx, 140); argcnt++;
  1071.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1072.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1073.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1074.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1075.     sprintf(text, "%d", vmax); 
  1076.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1077. /*    XtSetArg(args[argcnt], XmNvalue, "0"); argcnt++; */
  1078.     vmaxTF = XtCreateWidget("vmaxTF",
  1079.         xmTextFieldWidgetClass,
  1080.         chromaBBoard,
  1081.         args,
  1082.         argcnt);
  1083.     XtManageChild(vmaxTF);
  1084.     VmaxTF = vmaxTF; /* set global */
  1085.  
  1086.     argcnt = 0;
  1087.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1088.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1089.     XtSetArg(args[argcnt], XmNx, 100); argcnt++;
  1090.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1091.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1092.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1093.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1094.     sprintf(text, "%d", vmin); 
  1095.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1096. /*    XtSetArg(args[argcnt], XmNvalue, "0"); argcnt++; */
  1097.     vminTF = XtCreateWidget("vminTF",
  1098.         xmTextFieldWidgetClass,
  1099.         chromaBBoard,
  1100.         args,
  1101.         argcnt);
  1102.     XtManageChild(vminTF);
  1103.     VminTF = vminTF; /* set global */
  1104.  
  1105.     argcnt = 0;
  1106.     XtSetArg(args[argcnt], XmNhighlightOnEnter, False); argcnt++;
  1107.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1108.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1109.     XtSetArg(args[argcnt], XmNx, 60); argcnt++;
  1110.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1111.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1112.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1113.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1114.     sprintf(text, "%d", umax); 
  1115.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1116. /*    XtSetArg(args[argcnt], XmNvalue, "0"); argcnt++; */
  1117.     umaxTF = XtCreateWidget("umaxTF",
  1118.         xmTextFieldWidgetClass,
  1119.         chromaBBoard,
  1120.         args,
  1121.         argcnt);
  1122.     XtManageChild(umaxTF);
  1123.     UmaxTF = umaxTF; /* set global */
  1124.  
  1125.     argcnt = 0;
  1126.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1127.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1128.     XtSetArg(args[argcnt], XmNx, 20); argcnt++;
  1129.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1130.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1131.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1132.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1133.     sprintf(text, "%d", umin); 
  1134.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1135. /*    XtSetArg(args[argcnt], XmNvalue, "0"); argcnt++; */
  1136.     uminTF = XtCreateWidget("uminTF",
  1137.         xmTextFieldWidgetClass,
  1138.         chromaBBoard,
  1139.         args,
  1140.         argcnt);
  1141.     XtManageChild(uminTF);
  1142.     UminTF = uminTF; /* set global */
  1143.  
  1144.     return( retval );
  1145. }
  1146.  
  1147. /*
  1148.  * Function: CreatelumaBBoard()
  1149.  *        Create lumaBBoard hierarchy of widgets.
  1150.  */
  1151. Widget
  1152. CreatelumaBBoard( parent)
  1153. Widget parent;
  1154. {
  1155.     Arg        args[512];
  1156.     Cardinal       argcnt;
  1157.     Boolean       argok;
  1158.     char    text[50];
  1159.     int        scalevals[4];
  1160.     int        ymin,ymax;
  1161.     Widget     retval;
  1162.     Widget    lumaBBoard;
  1163.     Widget    yminTF;
  1164.     Widget    ymaxTF;
  1165.     Widget    lumasharpTF;
  1166.     Widget    lumafgopTF;
  1167.     Widget    yminScale;
  1168.     Widget    ymaxScale;
  1169.     Widget    yrangelockTB;
  1170.     Widget    lumasharpScale;
  1171.     Widget    lumafgopScale;
  1172.     Widget    yminLabel;
  1173.     Widget    ymaxLabel;
  1174.     Widget    lumasharpLabel;
  1175.     Widget    lumafgopLabel;
  1176.     Widget    lumasetTB;
  1177.     Widget    lumaDoPB;
  1178.     Widget    lumaAPB;
  1179.     Widget    lumaBPB;
  1180.     Widget    luma1PB;
  1181.     Widget    luma2PB;
  1182.     Widget    luma3PB;
  1183.     Widget    luma4PB;
  1184.  
  1185.     argok = False;
  1186.  
  1187.     BxRegisterConverters();
  1188.  
  1189.     getAllLumaVLValues(&scalevals);
  1190.     rangevaltominmax(scalevals[0],scalevals[1],&ymin,&ymax);
  1191.  
  1192.     argcnt = 0;
  1193.     XtSetArg(args[argcnt], XmNresizePolicy, XmRESIZE_GROW); argcnt++;
  1194.     XtSetArg(args[argcnt], XmNx, 1015); argcnt++;
  1195.     XtSetArg(args[argcnt], XmNy, 702); argcnt++;
  1196.     XtSetArg(args[argcnt], XmNwidth, 251); argcnt++;
  1197.     XtSetArg(args[argcnt], XmNheight, 310); argcnt++;
  1198.     lumaBBoard = XtCreateWidget("lumaBBoard",
  1199.         xmBulletinBoardWidgetClass,
  1200.         parent,
  1201.         args,
  1202.         argcnt);
  1203.     XtAddCallback(lumaBBoard, XmNdestroyCallback, lumaBBdestroyHandler,
  1204.           (XtPointer)0);
  1205.     retval = lumaBBoard;
  1206.  
  1207.     argcnt = 0;
  1208.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1209.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1210.     XtSetArg(args[argcnt], XmNx, 170); argcnt++;
  1211.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1212.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  1213.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1214.     luma4PB = XtCreateWidget("luma4PB",
  1215.         xmPushButtonWidgetClass,
  1216.         lumaBBoard,
  1217.         args,
  1218.         argcnt);
  1219.  
  1220.     XtAddCallback(luma4PB, XmNactivateCallback, luma4PBHandler, (XtPointer)0);
  1221.     XtManageChild(luma4PB);
  1222.  
  1223.     argcnt = 0;
  1224.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1225.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1226.     XtSetArg(args[argcnt], XmNx, 150); argcnt++;
  1227.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1228.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  1229.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1230.     luma3PB = XtCreateWidget("luma3PB",
  1231.         xmPushButtonWidgetClass,
  1232.         lumaBBoard,
  1233.         args,
  1234.         argcnt);
  1235.  
  1236.     XtAddCallback(luma3PB, XmNactivateCallback, luma3PBHandler, (XtPointer)0);
  1237.     XtManageChild(luma3PB);
  1238.  
  1239.     argcnt = 0;
  1240.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1241.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1242.     XtSetArg(args[argcnt], XmNx, 130); argcnt++;
  1243.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1244.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  1245.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1246.     luma2PB = XtCreateWidget("luma2PB",
  1247.         xmPushButtonWidgetClass,
  1248.         lumaBBoard,
  1249.         args,
  1250.         argcnt);
  1251.  
  1252.     XtAddCallback(luma2PB, XmNactivateCallback, luma2PBHandler, (XtPointer)0);
  1253.     XtManageChild(luma2PB);
  1254.  
  1255.     argcnt = 0;
  1256.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1257.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1258.     XtSetArg(args[argcnt], XmNx, 110); argcnt++;
  1259.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1260.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  1261.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1262.     luma1PB = XtCreateWidget("luma1PB",
  1263.         xmPushButtonWidgetClass,
  1264.         lumaBBoard,
  1265.         args,
  1266.         argcnt);
  1267.  
  1268.     XtAddCallback(luma1PB, XmNactivateCallback, luma1PBHandler, (XtPointer)0);
  1269.     XtManageChild(luma1PB);
  1270.  
  1271.     argcnt = 0;
  1272.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1273.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1274.     XtSetArg(args[argcnt], XmNx, 90); argcnt++;
  1275.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1276.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  1277.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1278.     lumaBPB = XtCreateWidget("lumaBPB",
  1279.         xmPushButtonWidgetClass,
  1280.         lumaBBoard,
  1281.         args,
  1282.         argcnt);
  1283.  
  1284.     XtAddCallback(lumaBPB, XmNactivateCallback, lumaBPBHandler, (XtPointer)0);
  1285.     XtManageChild(lumaBPB);
  1286.  
  1287.     argcnt = 0;
  1288.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1289.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1290.     XtSetArg(args[argcnt], XmNx, 70); argcnt++;
  1291.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1292.     XtSetArg(args[argcnt], XmNwidth, 20); argcnt++;
  1293.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1294.     lumaAPB = XtCreateWidget("lumaAPB",
  1295.         xmPushButtonWidgetClass,
  1296.         lumaBBoard,
  1297.         args,
  1298.         argcnt);
  1299.  
  1300.     XtAddCallback(lumaAPB, XmNactivateCallback, lumaAPBHandler, (XtPointer)0);
  1301.     XtManageChild(lumaAPB);
  1302.  
  1303.     argcnt = 0;
  1304.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1305.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1306.     XtSetArg(args[argcnt], XmNx, 20); argcnt++;
  1307.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1308.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1309.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1310.     lumaDoPB = XtCreateWidget("lumaDoPB",
  1311.         xmPushButtonWidgetClass,
  1312.         lumaBBoard,
  1313.         args,
  1314.         argcnt);
  1315.  
  1316.     XtAddCallback(lumaDoPB, XmNactivateCallback, lumaDoHandler, (XtPointer)0);
  1317.     XtManageChild(lumaDoPB);
  1318.  
  1319.     argcnt = 0;
  1320.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1321.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1322.     XtSetArg(args[argcnt], XmNx, 190); argcnt++;
  1323.     XtSetArg(args[argcnt], XmNy, 280); argcnt++;
  1324.     XtSetArg(args[argcnt], XmNwidth, 50); argcnt++;
  1325.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1326.     lumasetTB = XtCreateWidget("lumasetTB",
  1327.         xmToggleButtonWidgetClass,
  1328.         lumaBBoard,
  1329.         args,
  1330.         argcnt);
  1331.  
  1332.     XtAddCallback(lumasetTB, XmNvalueChangedCallback, lumasetTBHandler, (XtPointer)0);
  1333.     XtManageChild(lumasetTB);
  1334.     LumasetTB = lumasetTB; /* set global */
  1335.  
  1336.     argcnt = 0;
  1337.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1338.     XtSetArg(args[argcnt], XmNx, 160); argcnt++;
  1339.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  1340.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1341.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  1342.     lumafgopLabel = XtCreateWidget("lumafgopLabel",
  1343.         xmLabelWidgetClass,
  1344.         lumaBBoard,
  1345.         args,
  1346.         argcnt);
  1347.     XtManageChild(lumafgopLabel);
  1348.  
  1349.     argcnt = 0;
  1350.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1351.     XtSetArg(args[argcnt], XmNx, 120); argcnt++;
  1352.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  1353.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1354.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  1355.     lumasharpLabel = XtCreateWidget("lumasharpLabel",
  1356.         xmLabelWidgetClass,
  1357.         lumaBBoard,
  1358.         args,
  1359.         argcnt);
  1360.     XtManageChild(lumasharpLabel);
  1361.  
  1362.     argcnt = 0;
  1363.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1364.     XtSetArg(args[argcnt], XmNx, 80); argcnt++;
  1365.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  1366.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1367.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  1368.     ymaxLabel = XtCreateWidget("ymaxLabel",
  1369.         xmLabelWidgetClass,
  1370.         lumaBBoard,
  1371.         args,
  1372.         argcnt);
  1373.     XtManageChild(ymaxLabel);
  1374.  
  1375.     argcnt = 0;
  1376.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1377.     XtSetArg(args[argcnt], XmNx, 40); argcnt++;
  1378.     XtSetArg(args[argcnt], XmNy, 10); argcnt++;
  1379.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1380.     XtSetArg(args[argcnt], XmNheight, 20); argcnt++;
  1381.     yminLabel = XtCreateWidget("yminLabel",
  1382.         xmLabelWidgetClass,
  1383.         lumaBBoard,
  1384.         args,
  1385.         argcnt);
  1386.     XtManageChild(yminLabel);
  1387.  
  1388.     argcnt = 0;
  1389.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  1390.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  1391.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1392.     XtSetArg(args[argcnt], XmNx, 172); argcnt++;
  1393.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  1394.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  1395.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  1396.     XtSetArg(args[argcnt], XmNminimum, 0); argcnt++;
  1397.     XtSetArg(args[argcnt], XmNmaximum, 255); argcnt++;
  1398.     XtSetArg(args[argcnt], XmNvalue, scalevals[3]); argcnt++;  
  1399.     lumafgopScale = XtCreateWidget("lumafgopScale",
  1400.         xmScaleWidgetClass,
  1401.         lumaBBoard,
  1402.         args,
  1403.         argcnt);
  1404.  
  1405.     XtAddCallback(lumafgopScale, XmNdragCallback, lumafgopScaleHandler, (XtPointer)0);
  1406.     XtAddCallback(lumafgopScale, XmNvalueChangedCallback, lumafgopScaleHandler, (XtPointer)0);
  1407.     XtManageChild(lumafgopScale);
  1408.     LumafgopScale = lumafgopScale; /* set global */
  1409.  
  1410.  
  1411.     argcnt = 0;
  1412.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  1413.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  1414.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1415.     XtSetArg(args[argcnt], XmNx, 132); argcnt++;
  1416.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  1417.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  1418.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  1419.     XtSetArg(args[argcnt], XmNminimum, -8); argcnt++;
  1420.     XtSetArg(args[argcnt], XmNmaximum, 7); argcnt++;
  1421.     XtSetArg(args[argcnt], XmNvalue, scalevals[2]); argcnt++;  
  1422.     lumasharpScale = XtCreateWidget("lumasharpScale",
  1423.         xmScaleWidgetClass,
  1424.         lumaBBoard,
  1425.         args,
  1426.         argcnt);
  1427.  
  1428.     XtAddCallback(lumasharpScale, XmNdragCallback, lumasharpScaleHandler, (XtPointer)0);
  1429.     XtAddCallback(lumasharpScale, XmNvalueChangedCallback, lumasharpScaleHandler, (XtPointer)0);
  1430.     XtManageChild(lumasharpScale);
  1431.     LumasharpScale = lumasharpScale; /* set global */
  1432.  
  1433.     argcnt = 0;
  1434.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  1435.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  1436.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1437.     XtSetArg(args[argcnt], XmNx, 92); argcnt++;
  1438.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  1439.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  1440.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  1441.     XtSetArg(args[argcnt], XmNminimum, 0); argcnt++;
  1442.     XtSetArg(args[argcnt], XmNmaximum, 255); argcnt++;
  1443.     XtSetArg(args[argcnt], XmNvalue, ymax); argcnt++;  
  1444.     ymaxScale = XtCreateWidget("ymaxScale",
  1445.         xmScaleWidgetClass,
  1446.         lumaBBoard,
  1447.         args,
  1448.         argcnt);
  1449.  
  1450.     XtAddCallback(ymaxScale, XmNdragCallback, ymaxScaleHandler, (XtPointer)0);
  1451.     XtAddCallback(ymaxScale, XmNvalueChangedCallback, ymaxScaleHandler, (XtPointer)0);
  1452.     XtManageChild(ymaxScale);
  1453.     YmaxScale = ymaxScale; /* set global */
  1454.  
  1455.     argcnt = 0;
  1456.     XtSetArg(args[argcnt], XmNorientation, XmVERTICAL); argcnt++;
  1457.     XtSetArg(args[argcnt], XmNshowValue, False); argcnt++;
  1458.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1459.     XtSetArg(args[argcnt], XmNx, 52); argcnt++;
  1460.     XtSetArg(args[argcnt], XmNy, 58); argcnt++;
  1461.     XtSetArg(args[argcnt], XmNwidth, 19); argcnt++;
  1462.     XtSetArg(args[argcnt], XmNheight, 195); argcnt++;
  1463.     XtSetArg(args[argcnt], XmNminimum, 0); argcnt++;
  1464.     XtSetArg(args[argcnt], XmNmaximum, 255); argcnt++;
  1465.     XtSetArg(args[argcnt], XmNvalue, ymin); argcnt++;  
  1466.     yminScale = XtCreateWidget("yminScale",
  1467.         xmScaleWidgetClass,
  1468.         lumaBBoard,
  1469.         args,
  1470.         argcnt);
  1471.  
  1472.     XtAddCallback(yminScale, XmNdragCallback, yminScaleHandler, (XtPointer)0);
  1473.     XtAddCallback(yminScale, XmNvalueChangedCallback, yminScaleHandler, (XtPointer)0);
  1474.     XtManageChild(yminScale);
  1475.     YminScale = yminScale; /* set global */
  1476.  
  1477.  
  1478.     argcnt = 0;
  1479.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1480.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1481.     XtSetArg(args[argcnt], XmNx, 55); argcnt++;
  1482.     XtSetArg(args[argcnt], XmNy, 250); argcnt++;
  1483.     XtSetArg(args[argcnt], XmNwidth, 50); argcnt++;
  1484.     XtSetArg(args[argcnt], XmNheight, 30); argcnt++;
  1485.     yrangelockTB = XtCreateWidget("yrangelockTB",
  1486.         xmToggleButtonWidgetClass,
  1487.         lumaBBoard,
  1488.         args,
  1489.         argcnt);
  1490.  
  1491.     XtAddCallback(yrangelockTB, XmNvalueChangedCallback, yrangelockTBHandler, (XtPointer)0);
  1492.     XtManageChild(yrangelockTB);
  1493.     YrangelockTB = yrangelockTB; /* set global */
  1494.  
  1495.  
  1496.     argcnt = 0;
  1497.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1498.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1499.     XtSetArg(args[argcnt], XmNx, 160); argcnt++;
  1500.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1501.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1502.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1503.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1504.     sprintf(text, "%d", scalevals[3]); 
  1505.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1506.     lumafgopTF = XtCreateWidget("lumafgopTF",
  1507.         xmTextFieldWidgetClass,
  1508.         lumaBBoard,
  1509.         args,
  1510.         argcnt);
  1511.     XtManageChild(lumafgopTF);
  1512.     LumafgopTF = lumafgopTF; /* set global */
  1513.  
  1514.     argcnt = 0;
  1515.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1516.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1517.     XtSetArg(args[argcnt], XmNx, 120); argcnt++;
  1518.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1519.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1520.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1521.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1522.     sprintf(text, "%d", scalevals[2]); 
  1523.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1524.     lumasharpTF = XtCreateWidget("lumasharpTF",
  1525.         xmTextFieldWidgetClass,
  1526.         lumaBBoard,
  1527.         args,
  1528.         argcnt);
  1529.     XtManageChild(lumasharpTF);
  1530.     LumasharpTF = lumasharpTF; /* set global */
  1531.  
  1532.     argcnt = 0;
  1533.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1534.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1535.     XtSetArg(args[argcnt], XmNx, 80); argcnt++;
  1536.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1537.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1538.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1539.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1540.     sprintf(text, "%d", ymax); 
  1541.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1542.     ymaxTF = XtCreateWidget("ymaxTF",
  1543.         xmTextFieldWidgetClass,
  1544.         lumaBBoard,
  1545.         args,
  1546.         argcnt);
  1547.     XtManageChild(ymaxTF);
  1548.     YmaxTF = ymaxTF; /* set global */
  1549.  
  1550.     argcnt = 0;
  1551.     XtSetArg(args[argcnt], XmNhighlightOnEnter, False); argcnt++;
  1552.     XtSetArg(args[argcnt], XmNeditable, False); argcnt++;
  1553.     XtSetArg(args[argcnt], XmNcursorPositionVisible, False); argcnt++;
  1554.     XtSetArg(args[argcnt], XmNx, 40); argcnt++;
  1555.     XtSetArg(args[argcnt], XmNy, 28); argcnt++;
  1556.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1557.     XtSetArg(args[argcnt], XmNheight, 28); argcnt++;
  1558.     XtSetArg(args[argcnt], XmNmarginWidth, 1); argcnt++;
  1559.     sprintf(text, "%d", ymin); 
  1560.     XtSetArg(args[argcnt], XmNvalue, text); argcnt++;  
  1561.     yminTF = XtCreateWidget("yminTF",
  1562.         xmTextFieldWidgetClass,
  1563.         lumaBBoard,
  1564.         args,
  1565.         argcnt);
  1566.     XtManageChild(yminTF);
  1567.     YminTF = yminTF; /* set global */
  1568.  
  1569.     return( retval );
  1570. }
  1571.  
  1572. /*
  1573.  * Function: CreateswitchBBoard()
  1574.  *        Create switchBBoard hierarchy of widgets.
  1575.  */
  1576. Widget
  1577. CreateswitchBBoard( parent)
  1578. Widget parent;
  1579. {
  1580.     Arg        args[512];
  1581.     Cardinal       argcnt;
  1582.     Boolean       argok;
  1583.     Widget     retval;
  1584.     Widget    switchBBoard;
  1585.     Widget    upperleftswitchPB;
  1586.     Widget    tilesswitchPB;
  1587.     Widget    leftrightswitchPB;
  1588.     Widget    elevatorhorizswitchPB;
  1589.     Widget    crossswitchPB;
  1590.     Widget    squaresswitchPB;
  1591.     Widget    rectoutswitchPB;
  1592.     Widget    fadeswitchPB;
  1593.     Widget    automanualTB;
  1594.     Widget    switchspeedScale;
  1595.     Widget    fuzzScale;
  1596.     Widget    manualScale;
  1597.     Widget    repeatScale;
  1598.  
  1599.     argok = False;
  1600.  
  1601.     BxRegisterConverters();
  1602.  
  1603.     argcnt = 0;
  1604.     XtSetArg(args[argcnt], XmNresizePolicy, XmRESIZE_GROW); argcnt++;
  1605.     XtSetArg(args[argcnt], XmNx, 894); argcnt++;
  1606.     XtSetArg(args[argcnt], XmNy, 447); argcnt++;
  1607.     XtSetArg(args[argcnt], XmNwidth, 360); argcnt++;
  1608.     XtSetArg(args[argcnt], XmNheight, 310); argcnt++;
  1609.     switchBBoard = XtCreateWidget("switchBBoard",
  1610.         xmBulletinBoardWidgetClass,
  1611.         parent,
  1612.         args,
  1613.         argcnt);
  1614.     XtAddCallback(switchBBoard, XmNdestroyCallback, switchBBdestroyHandler,
  1615.           (XtPointer)0);
  1616.     retval = switchBBoard;
  1617.  
  1618.     argcnt = 0;
  1619.     XtSetArg(args[argcnt], XmNorientation, XmHORIZONTAL); argcnt++;
  1620.     XtSetArg(args[argcnt], XmNshowValue, True); argcnt++;
  1621.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1622.     XtSetArg(args[argcnt], XmNx, 210); argcnt++;
  1623.     XtSetArg(args[argcnt], XmNy, 220); argcnt++;
  1624.     XtSetArg(args[argcnt], XmNwidth, 104); argcnt++;
  1625.     XtSetArg(args[argcnt], XmNheight, 58); argcnt++;
  1626.     XtSetArg(args[argcnt], XmNvalue, 60); argcnt++;
  1627.     repeatScale = XtCreateWidget("repeatScale",
  1628.         xmScaleWidgetClass,
  1629.         switchBBoard,
  1630.         args,
  1631.         argcnt);
  1632.  
  1633.     XtAddCallback(repeatScale, XmNdragCallback, repeatScaleHandler, (XtPointer)0);
  1634.     XtAddCallback(repeatScale, XmNvalueChangedCallback, repeatScaleHandler, (XtPointer)0);
  1635.     XtManageChild(repeatScale);
  1636.  
  1637.     argcnt = 0;
  1638.     XtSetArg(args[argcnt], XmNorientation, XmHORIZONTAL); argcnt++;
  1639.     XtSetArg(args[argcnt], XmNshowValue, True); argcnt++;
  1640.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1641.     XtSetArg(args[argcnt], XmNx, 210); argcnt++;
  1642.     XtSetArg(args[argcnt], XmNy, 150); argcnt++;
  1643.     XtSetArg(args[argcnt], XmNwidth, 140); argcnt++;
  1644.     XtSetArg(args[argcnt], XmNheight, 59); argcnt++;
  1645.     manualScale = XtCreateWidget("manualScale",
  1646.         xmScaleWidgetClass,
  1647.         switchBBoard,
  1648.         args,
  1649.         argcnt);
  1650.  
  1651.     XtAddCallback(manualScale, XmNdragCallback, manualScaleHandler, (XtPointer)0);
  1652.     XtAddCallback(manualScale, XmNvalueChangedCallback, manualScaleHandler, (XtPointer)0);
  1653.     XtManageChild(manualScale);
  1654.     ManualScale = manualScale; /* set global */
  1655.  
  1656.     argcnt = 0;
  1657.     XtSetArg(args[argcnt], XmNorientation, XmHORIZONTAL); argcnt++;
  1658.     XtSetArg(args[argcnt], XmNshowValue, True); argcnt++;
  1659.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1660.     XtSetArg(args[argcnt], XmNx, 40); argcnt++;
  1661.     XtSetArg(args[argcnt], XmNy, 220); argcnt++;
  1662.     XtSetArg(args[argcnt], XmNwidth, 104); argcnt++;
  1663.     XtSetArg(args[argcnt], XmNheight, 58); argcnt++;
  1664.     XtSetArg(args[argcnt], XmNvalue, 100); argcnt++;
  1665.     fuzzScale = XtCreateWidget("fuzzScale",
  1666.         xmScaleWidgetClass,
  1667.         switchBBoard,
  1668.         args,
  1669.         argcnt);
  1670.  
  1671.     XtAddCallback(fuzzScale, XmNdragCallback, fuzzScaleHandler, (XtPointer)0);
  1672.     XtAddCallback(fuzzScale, XmNvalueChangedCallback, fuzzScaleHandler, (XtPointer)0);
  1673.     XtManageChild(fuzzScale);
  1674.     FuzzScale = fuzzScale; /* set global */
  1675.  
  1676.     argcnt = 0;
  1677.     XtSetArg(args[argcnt], XmNorientation, XmHORIZONTAL); argcnt++;
  1678.     XtSetArg(args[argcnt], XmNshowValue, True); argcnt++;
  1679.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1680.     XtSetArg(args[argcnt], XmNx, 40); argcnt++;
  1681.     XtSetArg(args[argcnt], XmNy, 150); argcnt++;
  1682.     XtSetArg(args[argcnt], XmNwidth, 104); argcnt++;
  1683.     XtSetArg(args[argcnt], XmNheight, 58); argcnt++;
  1684.     XtSetArg(args[argcnt], XmNvalue, 50); argcnt++;
  1685.     switchspeedScale = XtCreateWidget("switchspeedScale",
  1686.         xmScaleWidgetClass,
  1687.         switchBBoard,
  1688.         args,
  1689.         argcnt);
  1690.  
  1691.     XtAddCallback(switchspeedScale, XmNdragCallback, switchspeedScaleHandler, (XtPointer)0);
  1692.     XtManageChild(switchspeedScale);
  1693.     SwitchspeedScale = switchspeedScale; /* set global */
  1694.  
  1695.     argcnt = 0;
  1696.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1697.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1698.     XtSetArg(args[argcnt], XmNx, 250); argcnt++;
  1699.     XtSetArg(args[argcnt], XmNy, 60); argcnt++;
  1700.     XtSetArg(args[argcnt], XmNwidth, 110); argcnt++;
  1701.     XtSetArg(args[argcnt], XmNheight, 27); argcnt++;
  1702.     XtSetArg(args[argcnt], XmNset, True); argcnt++;
  1703.     automanualTB = XtCreateWidget("automanualTB",
  1704.         xmToggleButtonWidgetClass,
  1705.         switchBBoard,
  1706.         args,
  1707.         argcnt);
  1708.  
  1709.     XtAddCallback(automanualTB, XmNvalueChangedCallback, automanualTBHandler, (XtPointer)0);
  1710.     XtManageChild(automanualTB);
  1711.  
  1712.     argcnt = 0;
  1713.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1714.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1715.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1716.     XPM_PIXMAP(parent, fadeswitch)); argcnt++;
  1717.     XtSetArg(args[argcnt], XmNlabelString, 
  1718.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1719.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1720.     XtSetArg(args[argcnt], XmNx, 190); argcnt++;
  1721.     XtSetArg(args[argcnt], XmNy, 80); argcnt++;
  1722.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1723.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1724.     fadeswitchPB = XtCreateWidget("fadeswitchPB",
  1725.         xmPushButtonWidgetClass,
  1726.         switchBBoard,
  1727.         args,
  1728.         argcnt);
  1729.  
  1730.     XtAddCallback(fadeswitchPB, XmNactivateCallback, fadeswitchPBHandler, (XtPointer)0);
  1731.     XtManageChild(fadeswitchPB);
  1732.  
  1733.     argcnt = 0;
  1734.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1735.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1736.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1737.     XPM_PIXMAP(parent, rectoutswitch)); argcnt++;
  1738.     XtSetArg(args[argcnt], XmNlabelString, 
  1739.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1740.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1741.     XtSetArg(args[argcnt], XmNx, 190); argcnt++;
  1742.     XtSetArg(args[argcnt], XmNy, 30); argcnt++;
  1743.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1744.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1745.     rectoutswitchPB = XtCreateWidget("rectoutswitchPB",
  1746.         xmPushButtonWidgetClass,
  1747.         switchBBoard,
  1748.         args,
  1749.         argcnt);
  1750.  
  1751.     XtAddCallback(rectoutswitchPB, XmNactivateCallback, rectoutswitchPBHandler, (XtPointer)0);
  1752.     XtManageChild(rectoutswitchPB);
  1753.  
  1754.     argcnt = 0;
  1755.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1756.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1757.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1758.     XPM_PIXMAP(parent, squaresswitch)); argcnt++;
  1759.     XtSetArg(args[argcnt], XmNlabelString, 
  1760.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1761.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1762.     XtSetArg(args[argcnt], XmNx, 90); argcnt++;
  1763.     XtSetArg(args[argcnt], XmNy, 80); argcnt++;
  1764.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1765.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1766.     squaresswitchPB = XtCreateWidget("squaresswitchPB",
  1767.         xmPushButtonWidgetClass,
  1768.         switchBBoard,
  1769.         args,
  1770.         argcnt);
  1771.  
  1772.     XtAddCallback(squaresswitchPB, XmNactivateCallback, squaresswitchPBHandler, (XtPointer)0);
  1773.     XtManageChild(squaresswitchPB);
  1774.  
  1775.     argcnt = 0;
  1776.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1777.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1778.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1779.     XPM_PIXMAP(parent, crossswitch)); argcnt++;
  1780.     XtSetArg(args[argcnt], XmNlabelString, 
  1781.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1782.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1783.     XtSetArg(args[argcnt], XmNx, 140); argcnt++;
  1784.     XtSetArg(args[argcnt], XmNy, 30); argcnt++;
  1785.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1786.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1787.     crossswitchPB = XtCreateWidget("crossswitchPB",
  1788.         xmPushButtonWidgetClass,
  1789.         switchBBoard,
  1790.         args,
  1791.         argcnt);
  1792.  
  1793.     XtAddCallback(crossswitchPB, XmNactivateCallback, crossswitchPBHandler, (XtPointer)0);
  1794.     XtManageChild(crossswitchPB);
  1795.  
  1796.     argcnt = 0;
  1797.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1798.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1799.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1800.     XPM_PIXMAP(parent, elevatorhorizswitch)); argcnt++;
  1801.     XtSetArg(args[argcnt], XmNlabelString, 
  1802.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1803.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1804.     XtSetArg(args[argcnt], XmNx, 90); argcnt++;
  1805.     XtSetArg(args[argcnt], XmNy, 30); argcnt++;
  1806.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1807.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1808.     elevatorhorizswitchPB = XtCreateWidget("elevatorhorizswitchPB",
  1809.         xmPushButtonWidgetClass,
  1810.         switchBBoard,
  1811.         args,
  1812.         argcnt);
  1813.  
  1814.     XtAddCallback(elevatorhorizswitchPB, XmNactivateCallback, elevatorhorizswitchPBHandler, (XtPointer)0);
  1815.     XtManageChild(elevatorhorizswitchPB);
  1816.  
  1817.     argcnt = 0;
  1818.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1819.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1820.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1821.     XPM_PIXMAP(parent, lrdiag1switch)); argcnt++;
  1822.     XtSetArg(args[argcnt], XmNlabelString, 
  1823.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1824.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1825.     XtSetArg(args[argcnt], XmNx, 40); argcnt++;
  1826.     XtSetArg(args[argcnt], XmNy, 30); argcnt++;
  1827.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1828.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1829.     leftrightswitchPB = XtCreateWidget("leftrightswitchPB",
  1830.         xmPushButtonWidgetClass,
  1831.         switchBBoard,
  1832.         args,
  1833.         argcnt);
  1834.  
  1835.     XtAddCallback(leftrightswitchPB, XmNactivateCallback, leftrightswitchPBHandler, (XtPointer)0);
  1836.     XtManageChild(leftrightswitchPB);
  1837.  
  1838.     argcnt = 0;
  1839.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1840.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1841.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1842.     XPM_PIXMAP(parent, tilesswitch)); argcnt++;
  1843.     XtSetArg(args[argcnt], XmNlabelString, 
  1844.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1845.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1846.     XtSetArg(args[argcnt], XmNx, 140); argcnt++;
  1847.     XtSetArg(args[argcnt], XmNy, 80); argcnt++;
  1848.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1849.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1850.     tilesswitchPB = XtCreateWidget("tilesswitchPB",
  1851.         xmPushButtonWidgetClass,
  1852.         switchBBoard,
  1853.         args,
  1854.         argcnt);
  1855.  
  1856.     XtAddCallback(tilesswitchPB, XmNactivateCallback, tilesswitchPBHandler, (XtPointer)0);
  1857.     XtManageChild(tilesswitchPB);
  1858.  
  1859.     argcnt = 0;
  1860.     XtSetArg(args[argcnt], XmNhighlightOnEnter, True); argcnt++;
  1861.     XtSetArg(args[argcnt], XmNlabelType, XmPIXMAP); argcnt++;
  1862.     XtSetArg(args[argcnt], XmNlabelPixmap, 
  1863.     XPM_PIXMAP(parent, upperleftswitch)); argcnt++;
  1864.     XtSetArg(args[argcnt], XmNlabelString, 
  1865.              CONVERT(parent,"", "XmString", 0, &argok)); if (argok) argcnt++;
  1866.     XtSetArg(args[argcnt], XmNrecomputeSize, False); argcnt++;
  1867.     XtSetArg(args[argcnt], XmNx, 40); argcnt++;
  1868.     XtSetArg(args[argcnt], XmNy, 80); argcnt++;
  1869.     XtSetArg(args[argcnt], XmNwidth, 40); argcnt++;
  1870.     XtSetArg(args[argcnt], XmNheight, 41); argcnt++;
  1871.     upperleftswitchPB = XtCreateWidget("upperleftswitchPB",
  1872.         xmPushButtonWidgetClass,
  1873.         switchBBoard,
  1874.         args,
  1875.         argcnt);
  1876.  
  1877.     XtAddCallback(upperleftswitchPB, XmNactivateCallback, upperleftswitchPBHandler, (XtPointer)0);
  1878.     XtManageChild(upperleftswitchPB);
  1879.  
  1880.     return( retval );
  1881. }
  1882.  
  1883.